home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Graphics Plus
/
Graphics Plus.iso
/
amiga
/
gui
/
prcgntn1.lha
/
Precognition
/
source
/
ScrollingList.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-12-23
|
10KB
|
388 lines
#include <string.h>
#include "minmax.h"
#include "ScrollingList.h"
#include "ScrollingListClass.h"
#include "EmbossedGadgetClass.h"
#include "precognition.h"
#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include "amigamem.h"
#define CHAR_WIDTH 8 /* Width of Topaz 80 font. */
#define CHAR_HEIGHT 9 /* Height of Topaz 80 font. */
#define BROWSER_ENTRY_HEIGHT (CHAR_HEIGHT + 1)
#define BORDER_WIDTH 3
#define BASELINE 7
void ScrollingList_SetKnobInfo( ScrollingList *self )
{
USHORT position, knobsize, nElts, nRows;
nElts = self->list.List.nEntries;
if (nElts == 0)
{
position = 0;
knobsize = 0xFFFF;
}
else
{
nRows = self->list.nRows;
position = ((ULONG) self->list.YOffset << 16) / nElts;
if (nElts <= nRows)
{
knobsize = 0xFFFF;
}
else
{
knobsize = ((ULONG) nRows << 16) / nElts;
}
}
SetKnobSize( &self->vscroller, knobsize );
SetValue( &self->vscroller, position );
}
void ScrollingList_PositionList( ScrollingList *self )
{
USHORT position, /* Position of self->vscroller. */
new_YOffset, /* new list YOffset. */
nElts, /* # of elements in list. */
nRows, /* # of rows in display */
range; /* range of positions for YOffset */
ULONG temp;
nElts = self->list.List.nEntries;
if (nElts)
{
nRows = self->list.nRows;
if ((range = nElts - nRows +1) > 0)
{
position = Value( &self->vscroller );
temp = position * range;
new_YOffset = temp >>16;
new_YOffset = MIN( new_YOffset, nElts-1);
if (new_YOffset != self->list.YOffset)
{
self->list.YOffset = new_YOffset;
Refresh( &self->list );
}
}
}
}
void ScrollingList_Init( ScrollingList *self,
PIXELS LeftEdge,
PIXELS TopEdge,
PIXELS Width,
PIXELS Height,
pcg_3DPens Pens,
BOOL SelectMany )
{
Gadget *g;
StringLister_Init( self );
self->slister.isa = ScrollingListClass();
self->Pens = Pens;
ListBrowser_Init( &self->list, 0,0, 0,0, Pens, SelectMany );
VScroller_Init( &self->vscroller, 0,0, Height, Pens, NULL );
for ( g = FirstGadget( &self->list );
g->NextGadget != NULL;
g = g->NextGadget );
g->NextGadget = FirstGadget( &self->vscroller );
self->list.eg.Next = &self->vscroller;
SetSize( self, Width, Height );
SetLocation( self, LeftEdge, TopEdge );
}
void ScrollingList_CleanUp( ScrollingList *self )
{
CleanUp( &self->list );
CleanUp( &self->vscroller );
}
USHORT ScrollingList_nGadgets( ScrollingList *self )
{
return nGadgets( &self->list ) + nGadgets( &self->vscroller );
}
Gadget *ScrollingList_FirstGadget( ScrollingList *self )
{
return FirstGadget( &self->list );
}
Point ScrollingList_AskSize( ScrollingList *self,
PIXELS Width,
PIXELS Height )
{
Point size, list_size, vscroller_size;
vscroller_size = AskSize( &self->vscroller, Width, Height );
/* vscroller's have a fixed width */
list_size.x = Width - vscroller_size.x;
list_size.y = vscroller_size.y;
list_size = AskSize( &self->list, list_size.x, list_size.y );
size.x = list_size.x + vscroller_size.x;
size.y = list_size.y;
return size;
}
Point ScrollingList_SetSize( ScrollingList *self,
PIXELS Width,
PIXELS Height )
{
Point size, list_size, vscroller_size;
size = AskSize( self, Width, Height );
vscroller_size = SetSize( &self->vscroller, size.x, size.y );
list_size = SetSize( &self->list, size.x-vscroller_size.x, size.y );
self->slister.Size = size;
SetLocation( self, self->slister.Location.x, self->slister.Location.y );
ScrollingList_SetKnobInfo( self );
return size;
}
Point ScrollingList_SetLocation( ScrollingList *self,
PIXELS LeftEdge,
PIXELS TopEdge )
{
Point size, location;
size = Size( &self->list );
SetLocation( &self->list, LeftEdge, TopEdge );
SetLocation( &self->vscroller, LeftEdge+size.x, TopEdge );
location.x = LeftEdge;
location.y = TopEdge;
self->slister.Location = location;
return location;
}
USHORT ScrollingList_SetYOffset( ScrollingList *self,
USHORT YOffset )
{
return ListBrowser_SetYOffset( &self->list, YOffset );
}
void ScrollingList_Render( ScrollingList *self,
RastPort *RPort )
{
Render( &self->list, RPort );
Render( &self->vscroller, RPort );
}
void ScrollingList_SelectAll( ScrollingList *self, BOOL Select )
/* Selects or deselects everything in the list. */
{
ListBrowser_SelectAll( &self->list, Select );
}
const StringList *ScrollingList_StringList_of( ScrollingList *self )
{
return StringList_of( &self->list );
}
void ScrollingList_AddString( ScrollingList *self,
char *entry,
UBYTE qualifier )
{
AddString( &self->list, entry, qualifier );
ScrollingList_SetKnobInfo( self );
}
void ScrollingList_DeleteString( ScrollingList *self,
USHORT entry )
{
DeleteString( &self->list, entry );
ScrollingList_SetKnobInfo( self );
}
void ScrollingList_DeleteAllStrings( ScrollingList *self )
{
DeleteAllStrings( &self->list );
ScrollingList_SetKnobInfo( self );
}
void ScrollingList_SelectString( ScrollingList *self,
USHORT entry,
BOOL Select )
{
SelectString( &self->list, entry, Select );
}
void ScrollingList_Refresh( ScrollingList *self )
{
Refresh( &self->list );
Refresh( &self->vscroller );
}
USHORT ScrollingList_ClaimEvent( ScrollingList *self,
IntuiMessage *event )
{
return ClaimEvent( &self->list,event )
| ClaimEvent( &self->vscroller, event );
}
#define CLAIM_EVENT(b,e) (&b->g == (Gadget *) e->IAddress)
USHORT ScrollingList_Respond( ScrollingList *self,
IntuiMessage *Event )
{
USHORT list_response;
USHORT vscroller_response = 0;
list_response = Respond( &self->list, Event );
if (! (list_response & CONSUMED_EVENT))
{
vscroller_response = Respond( &self->vscroller, Event );
if (vscroller_response & CHANGED_STATE)
{
ScrollingList_PositionList( self );
/* scroll list */
vscroller_response = RESPONDED; /* Don't propagate the CHANGED_STATE. */
}
}
return list_response | vscroller_response;
}
void ScrollingList_SetInteractorWindow( ScrollingList *self,
pcgWindow *window )
{
self->slister.IaWindow = window;
SetInteractorWindow( &self->list, window );
SetInteractorWindow( &self->vscroller, window );
}
ULONG ScrollingList_IDCMPFlags( ScrollingList *self )
{
return IDCMPFlags( &self->list ) | IDCMPFlags( &self->vscroller );
}
BOOL ScrollingList_EnableIactor( ScrollingList *self, BOOL enable )
{
EnableIactor( &self->list, enable );
EnableIactor( &self->vscroller, enable );
return enable;
}
#ifdef BUILDER
#include "BuilderMethods.h"
#include "GraphicObject_Builder.h"
#include "ScrollingList_Builder.h"
#include "ScrollingList_Coder.h"
void ScrollingList_PropEdit( ScrollingList *self,
pcgWindow *window,
pcg_3DPens pens );
ScrollingList *ScrollingList_New( ScrollingList *self )
{
ScrollingList *new_list = NULL;
Point loc, size;
if (new_list = (ScrollingList*) Amalloc(sizeof(ScrollingList)))
{
loc = Location(self);
size = Size(self);
ScrollingList_Init( new_list, loc.x, loc.y,
size.x, size.y, self->Pens, self->list.SelectMany );
GiveItAName( new_list );
StringList_Dup( &self->list.List, &new_list->list.List );
}
return new_list;
}
struct BuilderMethods ScrollingList_bm;
#endif
BOOL ScrollingList_elaborated = FALSE;
struct StringListerClass ScrollingList_Class;
void ScrollingListClass_Init( struct StringListerClass *class )
{
StringListerClass_Init( class );
class->isa = StringListerClass();
class->CleanUp = ScrollingList_CleanUp;
class->ClassName = "ScrollingList";
class->AskSize = ScrollingList_AskSize;
class->SetSize = ScrollingList_SetSize;
class->SetLocation = ScrollingList_SetLocation;
class->Respond = ScrollingList_Respond;
class->Refresh = ScrollingList_Refresh;
class->Render = ScrollingList_Render;
class->ClaimEvent = ScrollingList_ClaimEvent;
class->nGadgets = ScrollingList_nGadgets;
class->FirstGadget = ScrollingList_FirstGadget;
class->SetInteractorWindow = ScrollingList_SetInteractorWindow;
class->IDCMPFlags = ScrollingList_IDCMPFlags;
class->isEnabled = EmbossedGadget_isEnabled;
class->EnableIactor = ScrollingList_EnableIactor;
class->StringList_of = ScrollingList_StringList_of;
class->AddString = ScrollingList_AddString;
class->DeleteString = ScrollingList_DeleteString;
class->DeleteAllStrings = ScrollingList_DeleteAllStrings;
class->SelectString = ScrollingList_SelectString;
#ifdef BUILDER
go_InitBuilderMethods( &ScrollingList_bm );
ScrollingList_bm.New = ScrollingList_New;
ScrollingList_bm.PropEdit = ScrollingList_PropEdit;
ScrollingList_bm.WriteCode = ScrollingList_WriteCode;
class->BuilderMethods = &ScrollingList_bm;
#endif
}
struct StringListerClass *ScrollingListClass( void )
{
if (! ScrollingList_elaborated)
{
ScrollingListClass_Init( &ScrollingList_Class );
ScrollingList_elaborated = TRUE;
}
return &ScrollingList_Class;
}